#pragma once
#include "SMAC_OP_enum.h"
#include "../../instruction_module/instruction.h"
#include"../../execution_module/write_delay_control/write_delay_control.h"
#include <iostream>
#include "../../System_config.h"

class SMAC {
public:
    SMAC(std::vector<base_operand*>* operands, int smac_id) 
                : operand_list(operands), id(smac_id){
        delay_cycles = 1;
    }
    SMAC(int smac_id, RegisterFile* rf) : id(smac_id), RF(rf) {
        delay_cycles = 1;
    }
    ~SMAC() {}
    int get_delay();
    void input_operands(std::vector<base_operand*>* operands);
    uint64_t Execute(instruction* smac_instr);
    write_req_info_reg  upload_write_msg();
    inline uint64_t read_Reg(int reg_id);
    inline void write_Reg(int reg_id, uint64_t value, int delay);
    inline uint64_t do_SFMULD(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULS32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULAD(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULAS32(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULBD(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULBS32(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_SFDOT32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCREAL32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCIMAG32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFADDH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFSUBH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULAH16(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_SFMULBH16(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPEH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPGH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPLH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFHINT16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFHTRU16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFINTH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFINTHU16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFSPHP16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFHPSP16L(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFHPSP16H(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFMANH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFLOGH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFABSH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFMAX16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFEXTS32L(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFEXTS32H(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFEXTH16LL(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFEXTH16LH(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFEXTH16HL(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFEXTH16HH(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SADD32_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADD32_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADDU32_src1_r_SMAC(int src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADDU32_src1_imm_SMAC(uint64_t src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADD_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADD_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADDU_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SADDU_src1_imm_SMAC(uint64_t src1, int src2_reg_id, int dst_reg_id); //未理解饱和操作和异常处理
    inline uint64_t do_SADDA_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id); //ai写的
    inline uint64_t do_SADDA_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUB32_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUB32_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUBU32_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUBU32_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUB_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUB_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUBU_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUBU_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUBA_src1_r_SMAC(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SSUBA_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SMULISU32_src1_r(int src1_reg_id, int src2_reg_id, int dst_reg_id); //描述理解不清
    inline uint64_t do_SMULISU32_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SMULIS32_src1_r(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SMULIS32_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SMULIS_src1_r(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SMULIS_src2_imm(uint64_t src1, int src2_reg_id, int dst_reg_id);





    inline uint64_t do_SMOV(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SMOVI(uint64_t imm, int dst_reg_id);


    inline uint64_t do_SFCMPED(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPES32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPGD(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPGS32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPLD(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFCMPLS32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFDINT(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFSINT32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFDTRU(int src_reg_id, int dst_reg_id); //???
    inline uint64_t do_SFSTRU32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFINTD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFINTDU(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFINTS32(int src_reg_id, int dst_reg_id); //???
    inline uint64_t do_SFINTSU32(int src_reg_id, int dst_reg_id); //???
    inline uint64_t do_SFDPSP32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_SFSPDP32T(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFSPHDP32T(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFMAND(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFMANS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFLOGD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFLOGS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFABSD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFABSS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFRSQD(int src_reg_id, int dst_reg_id); //以下没整明白描述
    inline uint64_t do_SFRSQS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFRCPD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_SFRCPS32(int src_reg_id, int dst_reg_id);

    inline uint64_t do_SVBCAST(int src_reg_id, int dst_reg_id);
    // 因为SVBCAST2指令的返回结果是两个寄存器的值，无法用单一的double返回
    // 所以该特例在SPU直接处理，不在SMAC内部执行
    // inline double do_SVBCAST2(int src_reg_id, int dst_reg_id);


private:
    double src_1;
    double src_2;
    double src_3;
    double dst;
    // //此处VMAC内部存储输入的值而不是寄存器编号，目的是方便VMAC类更好地去计算
    // //读取寄存器的功能放到VPU类内部，再将16*64的寄存器读取结果分配给16个VMAC
    // double src_1;
    // double src_2;
    // double src_3;
    int id; //SMAC单元的ID号，0～15
    std::vector<base_operand*>* operand_list;
    //!delay应修改为与指令绑定，同一个硬件模块可能执行多个指令，有着不同的延迟周期
    //以下三个private成员为每个步进周期内，存储写入结果的临时变量
    uint64_t res_value;
    int dst_reg_id;
    int delay_cycles; //用于标记该硬件单元从接收到输入，直到给出输出的延迟周期，根据不同的指令类型，应有不同的延迟周期

    RegisterFile* RF;


    //以下类型转换为ai提供的方法
    static inline float int16_to_float(int16_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    inline static int countl_zero(uint32_t x) {
        int n = 0;
        if (x == 0) return 32;
        while ((x & 0x80000000) == 0) {
            n++;
            x <<= 1;
        }
        return n;
    }

    // f16的格式定义：https://en.wikipedia.org/wiki/Half-precision_floating-point_format
    // f32的格式定义：https://en.wikipedia.org/wiki/Single-precision_floating-point_format
    // Fraction和man、Significand、mantissa 指的同一个东西，都是尾数位，F16的最后10位，F32的最后23位。
    static float fp16_to_float(uint16_t i)
    {
        // Check for signed zero, 根据F16的表示规则，如果Exponent(5位)和Significand(10位)都为0，那么表示浮点数zero, -0
        // 转换成f32只需要向右移16位构成32位表示就可以了，即符号位+31位0
        if ((i & 0x7FFF) == 0)
        {
            uint32_t result = (static_cast<uint32_t>(i) << 16);
            float f = 0.0;
            std::memset(&f, 0, sizeof(f));
            std::memcpy(&f, &result, sizeof(result));
            return f;
        }

        // 根据f16的IEEE754-2008标准，获取sign，Exponent，Significand的值
        uint32_t half_sign = (i & 0x8000);
        uint32_t half_exp = (i & 0x7C00);
        uint32_t half_man = (i & 0x03FF);

        // Check for an infinity or NaN when all exponent bits set
        // 如果Exponent（5位）对应的bit位全是1，即11111，那么可能是infinity or NaN 
        if (half_exp == 0x7C00)
        {
            // 如果Significand（10位）是0，就表示+-infinity（无穷）
            // Check for signed infinity if mantissa is zero
            if (half_man == 0)
            {
                // 转换位float32就是，符号位 + float32的+-infinity表示
                // 即符号位：（half_sign << 16）
                // float32的+-infinity表示： Exponent（占用8bit）全为1，fraction（23bit）全为0，即0x7F800000
                uint32_t result = (half_sign << 16) | 0x7F800000;
                float f = 0.0;
                std::memset(&f, 0, sizeof(f));
                std::memcpy(&f, &result, sizeof(result));
                return f;
            }
            else
            {
                // 如果Significand（10位）不是0， 就表示NaN
                // 转换为对应Float32的NaN，即Exponent（占用8bit）全为1；fraction（23bit）为half_man右移动13位（f32的fraction表示位数减去f16的fraction表示的位数，即23 - 10等于13）
                // NaN, keep current mantissa but also set most significiant mantissa bit
                // 为啥不是 0x7F800000??? 
                uint32_t result = (half_sign << 16) | 0x7FC00000 | (half_man << 13);
                float f = 0.0;
                std::memset(&f, 0, sizeof(f));
                std::memcpy(&f, &result, sizeof(result));
                return f;
            }
        }

        // Calculate single-precision components with adjusted exponent
        // 转换为f32的符号位，右移动16位
        uint32_t sign = half_sign << 16;
        // Unbias exponent
        // 因为F16的Exponent的表示的不是e为底，Exponent为指数的指数函数，而是指数为Exponent-15，偏移量为15
        // 对应F32的偏移量为127，所以换成F32的Exponent就要E - 15 + 127表示
        int32_t unbiased_exp = (static_cast<int32_t>(half_exp) >> 10) - 15;
        
        // 通过前面的条件过滤，这里表示Exponent全为0，Significand不全为0，表示subnormal number
        // Check for subnormals, which will be normalized by adjusting exponent
        if (half_exp == 0)
        {
            // Calculate how much to adjust the exponent by
            int e = countl_zero(half_man) - 6;

            // Rebias and adjust exponent
            uint32_t exp = (127 - 15 - e) << 23;
            uint32_t man = (half_man << (14 + e)) & 0x7FFFFF;
            uint32_t result = sign | exp | man;
            float f = 0.0;
            std::memset(&f, 0, sizeof(f));
            std::memcpy(&f, &result, sizeof(result));
            return f;
        }

        // Rebias exponent for a normalized normal
        // 这里的加127，对应上面说的F16转F32时Exponent要加上F32的Exponent偏移量127；向右移动23位到达表示Exponent对应的bit位置
        uint32_t exp = (static_cast<uint32_t>(unbiased_exp + 127)) << 23;
        // 向右移动13位，Significand值由F16的10位表示转换成23位表示
        uint32_t man = (half_man & 0x03FF) << 13;
        uint32_t result = sign | exp | man;
        float f = 0.0;
        std::memset(&f, 0, sizeof(f));
        std::memcpy(&f, &result, sizeof(result));
        return f;
    }

    // Fraction和man、Significand、mantissa 指的同一个东西，都是尾数位，F16的最后10位，F32的最后23位。
    // In the below functions, round to nearest, with ties to even.
    // Let us call the most significant bit that will be shifted out the round_bit.
    //
    // Round up if either
    //  a) Removed part > tie.
    //     (mantissa & round_bit) != 0 && (mantissa & (round_bit - 1)) != 0
    //  b) Removed part == tie, and retained part is odd. F32的Fraction右移动13位后，剩下部分是奇数，可以进位
    //     (mantissa & round_bit) != 0 && (mantissa & (2 * round_bit)) != 0
    // F32的Fraction右移动13位后，剩下部分是奇数，可以进位
    // (If removed part == tie and retained part is even, do not round up.)
    // These two conditions can be combined into one:
    //     (mantissa & round_bit) != 0 && (mantissa & ((round_bit - 1) | (2 * round_bit))) != 0
    // which can be simplified into
    //     (mantissa & round_bit) != 0 && (mantissa & (3 * round_bit - 1)) != 0
    static uint16_t float_to_fp16(float value)
    {
        // Convert to raw bytes
        uint32_t x;
        std::memset(&x, 0, sizeof(uint32_t));
        std::memcpy(&x, &value, sizeof x);

        // Extract IEEE754 components
        uint32_t sign = x & 0x80000000u;
        uint32_t exp = x & 0x7F800000u;
        uint32_t man = x & 0x007FFFFFu;

        // Check for all exponent bits being set, which is Infinity or NaN
        // Exponent全为1，表示Infinity or NaN
        if (exp == 0x7F800000u)
        {
            uint32_t nan_bit = (man == 0) ? 0 : 0x0200u;
            // 0x7C00u 表示F16的Exponent全为1
            // nan_bit：如果man==0，表示+-infinity，所以直接把(man >> 13)就变成了F16的man
            // 如果man != 0, 把（man >> 13）可能变成了0，所以加上一个nan_bit，确保转换成的F16！=0
            return (sign >> 16) | 0x7C00u | nan_bit | (man >> 13);
        }

        // 右移16bit转换成F16的sign
        uint32_t half_sign = sign >> 16;
        // 127是F32的Exponent的偏移
        // 从F32的Exponent转换成F16，就需要exp的值 - 127 + 15, 15是F16的偏移
        int32_t unbiased_exp = ((exp >> 23) - 127);
        int32_t half_exp = unbiased_exp + 15;

        // 表示half_exp超过F16的Exponent最大表示，11111
        // Check for exponent overflow, return +infinity
        // 表示infinity
        if (half_exp >= 0x1F)
        {
            // 0x7C00u表示，F16表示的bit位，Fraction全部为0, Exponent全部为1
            return half_sign | 0x7C00u;
        }

        // Check for underflow
        if (half_exp <= 0)
        {
            // Check mantissa for what we can do
            if ((14 - half_exp) > 24)
            {
                // No rounding possibility, so this is a full underflow, return signed zero
                return half_sign;
            }
            man = man | 0x00800000u;
            uint32_t half_man = man >> (14 - half_exp);
            uint32_t round_bit = 1 << (13 - half_exp);
            if ((man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0)
            {
                half_man++;
            }
            return half_sign | half_man;
        }
        // Rebias the exponent, 左移10位到F16的Exponent表示位置
        half_exp = (half_exp << 10);
        // 右移动13位，到F16的Significand表示位置
        uint32_t half_man = man >> 13;
        // round_bit表示F32的Fraction中的从右往左的第13位，也就是转换成F16（10位）时要移除的最后一个位置。
        uint32_t round_bit = 0x00001000u;
        // Check for rounding (see comment above functions)
        if ((man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0)
        {
            // Round it
            return (half_sign | half_exp | half_man) + (uint32_t)1;
        }
        else
        {
            return half_sign | half_exp | half_man;
        }
    }

//     float fp16_to_float(uint16_t fp16) {
//     // 实现 fp16 到 float 的转换逻辑
//     // 这里可以使用库函数或手动实现
//     // 以下是一个简单的示例实现（假设 fp16 是 IEEE 754 半精度格式）
//     uint32_t sign = (fp16 >> 15) & 0x1;
//     uint32_t exponent = (fp16 >> 10) & 0x1F;
//     uint32_t mantissa = fp16 & 0x3FF;

//     if (exponent == 0) {
//         // 零或非规格化数
//         return (sign ? -0.0f : 0.0f);
//     } else if (exponent == 0x1F) {
//         // 无穷大或 NaN
//         return (mantissa == 0) ? (sign ? -INFINITY : INFINITY) : NAN;
//     } else {
//         // 规格化数
//         exponent -= 15; // 调整指数偏移
//         mantissa |= 0x400; // 添加隐含的 1
//         float value = std::ldexp(mantissa, exponent - 10);
//         return sign ? -value : value;
//     }
// }


//     uint16_t float_to_fp16(float value) {
//     // 实现 float 到 fp16 的转换逻辑
//     // 这里可以使用库函数或手动实现
//     // 以下是一个简单的示例实现（假设 fp16 是 IEEE 754 半精度格式）
//     uint32_t bits = *reinterpret_cast<uint32_t*>(&value);
//     uint32_t sign = (bits >> 31) & 0x1;
//     uint32_t exponent = (bits >> 23) & 0xFF;
//     uint32_t mantissa = bits & 0x7FFFFF;

//     if (exponent == 0xFF) {
//         // 无穷大或 NaN
//         return (sign << 15) | 0x7C00 | (mantissa ? 0x200 : 0);
//     } else if (exponent == 0) {
//         // 零或非规格化数
//         return (sign << 15);
//     } else {
//         // 规格化数
//         exponent -= 127; // 调整指数偏移
//         if (exponent > 15) {
//             // 溢出，返回无穷大
//             return (sign << 15) | 0x7C00;
//         } else if (exponent < -14) {
//             // 非规格化数
//             return (sign << 15);
//         } else {
//             // 规格化数
//             exponent += 15; // 调整指数偏移
//             mantissa >>= 13; // 截断尾数
//             return (sign << 15) | (exponent << 10) | mantissa;
//         }
//     }
// }

    static inline float uint32_to_float(uint32_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline float int32_to_float(int32_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline uint32_t float_to_uint32(float f) {
        uint32_t v;
        std::memcpy(&v, &f, sizeof(v));
        return v;
    }

    static inline int32_t float_to_int32(float f) {
        int32_t v;
        std::memcpy(&v, &f, sizeof(v));
        return v;
    }

    static inline float double_to_float(double v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline float float_to_double(float v) {
        double f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline double uint64_to_float(uint64_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline double uint64_to_double(uint64_t v) {
        double f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline double int64_to_double(int64_t v) {
        double f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline int64_t double_to_int64(double v) {
        int64_t f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline int64_t double_to_uint64(double v) {
        uint64_t f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }


    static inline uint64_t fraction_16(uint16_t fp16) {
        uint64_t fp16_1 = static_cast<uint64_t>(fp16 & 0x03FF);
        uint64_t fp16_2 = fp16_1 || 0x0400; //加上隐含的1
        uint64_t fp16_3 = fp16_2 << 4;
        return fp16_3;
    }

    static inline uint64_t fraction_32(uint32_t f) {
        uint64_t f_1 = static_cast<uint64_t>(f & 0x007FFFFF);
        uint64_t f_2 = f_1 || 0x00800000; //加上隐含的1
        uint64_t f_3 = f_2 << 7;
        return f_3;
    }

    static inline uint64_t exponent(uint16_t fp16) {
        uint64_t exp_1 = static_cast<uint64_t>((fp16 & 0x7C00) >> 10);
        uint64_t exp_2 = exp_1 - 15;
        return exp_2;
    }

    //求倒数平方根近似值
    double sqrcp(double x) {
    const float threehalfs = 1.5F;

    double xhalf = 0.5F * x;
    int i = *(int*)&x;  // 将浮点数的二进制表示转换为整数
    i = 0x5f3759df - (i >> 1);  // 魔法常数和位运算
    x = *(double*)&i;  // 将整数转换回浮点数
    x = x * (threehalfs - (xhalf * x * x));  // 牛顿迭代逼近

    return x;
}

};





